package blue.global.util;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Random;

/**
 * 字符串工具类
 * 
 * @author zhengj
 * @since 2009-2-15 1.0
 */
public class StringUtil
{
	private static Random rand = new Random();
	
	/**
	 * 把字符串数组连接成一个字符串
	 * 
	 * @param prefix 分割符
	 * @param before 字符串的前缀
	 * @param after 字符串的后缀
	 * @param items 字符串数组
	 * @return 连接成的字符串
	 */
	public static String concat(String prefix, String before, String after, String...items)
	{
		return concat(prefix, before, after, Arrays.asList(items));
	}
	
	/**
	 * 把字符串列表连接成一个字符串
	 * 
	 * @param prefix 分割符
	 * @param before 字符串的前缀
	 * @param after 字符串的后缀
	 * @param items 字符串列表
	 * @return 连接成的字符串
	 */
	public static String concat(String prefix, String before, String after, Collection<String> itemList)
	{
		StringBuilder sb = new StringBuilder();
		for (String item : itemList)
		{
			sb.append(before).append(item).append(after).append(prefix);
		}
		sb.delete(sb.length() - prefix.length(), sb.length());
		return sb.toString();
	}
	/**
	 * 把字符串数组连接成一个字符串
	 * 
	 * @param prefix 分割符
	 * @param items 字符串数组
	 * @return 连接成的字符串
	 */
	public static String concat(String prefix, String...items)
	{
		return concat(prefix, Arrays.asList(items));
	}
	
	/**
	 * 把字符串列表连接成一个字符串
	 * 
	 * @param prefix 分割符
	 * @param itemList 字符串列表
	 * @return 连接成的字符串
	 */
	public static String concat(String prefix, Collection<String> itemList)
	{
		StringBuilder sb = new StringBuilder();
		for (String item : itemList)
		{
			sb.append(item).append(prefix);
		}
		sb.delete(sb.length() - prefix.length(), sb.length());
		return sb.toString();
	}
	
	/**
	 * 重复字符串
	 * 
	 * @param prefix 分割符
	 * @param item 重复字符串
	 * @param times 重复次数
	 * @return 如果重复次数小于2，则返回字符串
	 */
	public static String repeat(String prefix, String item, int times)
	{
		if (times <= 1)
			return item;
		
		StringBuilder sb = new StringBuilder();
		for (int i = 0; i < times; i++)
		{
			sb.append(item).append(prefix);
		}
		sb.delete(sb.length() - prefix.length(), sb.length());
		return sb.toString();
	}
	
	/**
	 * 根据起始编号和结束编号生成一个编号序列
	 * 
	 * @param begin 起始编号
	 * @param end 结束编号
	 * @return 编号序列，如果起始编号大于结束编号，则返回 null
	 */
	public static List<String>	 sequence(String begin, String end)
	{
		long b = Long.parseLong(begin);
		long e = Long.parseLong(end);
		if (b > e)
			return null;
		
		List<String> list = new ArrayList<String>();
		for (long i = b; i <= e; i++)
		{
			list.add(NumberUtil.toString(i, begin.length()));
		}
		return list;
	}
	
	/**
	 * 根据起始编号和序列长度生成一个编号序列
	 * 
	 * @param begin 起始编号
	 * @param end 序列长度
	 * @return 编号序列, 如果序列长度小于 0，则返回 null
	 */
	public static List<String>	 sequence(String begin, int length)
	{
		if (length <= 0)
			return null;
		
		List<String> list = new ArrayList<String>();
		long b = Long.parseLong(begin);
		list.add(begin);
		for (int i = 1; i <= length; i++)
		{
			list.add(NumberUtil.toString(++b, begin.length()));
		}
		return list;
	}
	
	/**
	 * 产生随机字符串
	 * 
	 * @param length 字符串个数
	 * @return 随机字符串
	 */
	public static String random(int length)
	{
		int h = length >> 1;
		int l = length & 1;

		StringBuilder sb = new StringBuilder(length);
		if (h > 0) //一个字节占两位
		{
			byte[] bytes = new byte[h];
			rand.nextBytes(bytes);
			sb.append(NumberUtil.toHexString(bytes));
		}
		if (l > 0)
		{
			sb.append(Integer.toHexString(rand.nextInt(16)));
		}
		return sb.toString();
	}
	
	/**
	 * <p>把字符串转化为映射</p>
	 * 字符串格式为：{key1:value1, key2: value2, ...}
	 * 
	 * @param val 字符串
	 * @return 映射，如果格式不符合则返回空映射或直到不符合的位置
	 */
	public static Map<String, String> toMap(String val)
	{
		Map<String, String> map = new HashMap<String, String>();
		
		if (val == null)
			return map;
		val = val.trim();
		if (!val.startsWith("{") || !val.endsWith("}"))
			return map;
		
		val = val.substring(1, val.length() - 1);
		String[] entries = val.split(",");
		for (String entry : entries)
		{
			String[] keyValue = entry.split(":");
			if (keyValue.length != 2)
				return map;
			
			map.put(keyValue[0], keyValue[1]);
		}
		return map;
	}
}
